package com.example.apitesttool.agent;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.HashMap;
import java.util.Map;

/**
 * 智能体流程图执行器
 * 驱动整个智能体决策流程的执行
 */
@Service
public class AgentGraphExecutor {
    
    private static final Logger logger = LoggerFactory.getLogger(AgentGraphExecutor.class);
    
    // 用于测试的包可见字段
    AgentRouter agentRouter;
    
    // 节点注册表
    private final Map<String, AgentNode> nodeRegistry = new HashMap<>();
    
    @Autowired
    public void setAgentRouter(AgentRouter agentRouter) {
        this.agentRouter = agentRouter;
    }
    
    /**
     * 注册节点
     * @param nodeName 节点名称
     * @param node 节点实例
     */
    public void registerNode(String nodeName, AgentNode node) {
        nodeRegistry.put(nodeName, node);
        logger.info("注册智能体节点: {} - {}", nodeName, node.getNodeDescription());
    }
    
    /**
     * 执行智能体流程图
     * @param userQuery 用户查询
     * @return 最终响应
     */
    public String execute(String userQuery) {
        logger.info("开始执行智能体流程，用户查询: {}", userQuery);
        
        // 初始化状态
        AgentState state = new AgentState();
        state.setUserQuery(userQuery);
        state.addToHistory("用户: " + userQuery);
        
        // 获取初始节点
        String currentNodeName = agentRouter.getInitialNode();
        AgentNodeResult lastResult = null;
        
        try {
            // 执行流程图
            while (agentRouter.shouldContinue(state, lastResult)) {
                state.incrementStep();
                
                logger.debug("执行步骤 {}: 当前节点 = {}", state.getStepCount(), currentNodeName);
                
                // 获取当前节点
                AgentNode currentNode = nodeRegistry.get(currentNodeName);
                if (currentNode == null) {
                    logger.error("未找到节点: {}", currentNodeName);
                    state.setError("系统错误：未找到处理节点 " + currentNodeName);
                    break;
                }
                
                // 检查节点是否可以执行
                if (!currentNode.canExecute(state)) {
                    logger.warn("节点 {} 无法执行，跳过", currentNodeName);
                    currentNodeName = agentRouter.routeNext(state, null);
                    continue;
                }
                
                // 执行节点
                try {
                    lastResult = currentNode.execute(state);
                    logger.debug("节点 {} 执行完成，结果: {}", currentNodeName, lastResult.getMessage());
                    
                    // 如果执行失败，设置错误状态
                    if (!lastResult.isSuccess()) {
                        state.setError(lastResult.getMessage());
                    }
                    
                } catch (Exception e) {
                    logger.error("节点 {} 执行异常", currentNodeName, e);
                    state.setError("执行过程中发生错误: " + e.getMessage());
                    lastResult = AgentNodeResult.failure("节点执行异常: " + e.getMessage());
                }
                
                // 决定下一个节点
                String nextNodeName = agentRouter.routeNext(state, lastResult);
                if (nextNodeName == null || nextNodeName.equals(currentNodeName)) {
                    logger.debug("没有下一个节点或循环检测，结束执行");
                    break;
                }
                
                currentNodeName = nextNodeName;
            }
            
            // 生成最终响应
            return generateFinalResponse(state, lastResult);
            
        } catch (Exception e) {
            logger.error("智能体执行过程中发生异常", e);
            return "抱歉，处理您的请求时发生了错误: " + e.getMessage();
        }
    }
    
    /**
     * 生成最终响应
     * @param state 智能体状态
     * @param lastResult 最后的执行结果
     * @return 最终响应
     */
    private String generateFinalResponse(AgentState state, AgentNodeResult lastResult) {
        StringBuilder response = new StringBuilder();
        
        // 如果有错误
        if (state.hasError()) {
            response.append("❌ ").append(state.getErrorMessage());
            return response.toString();
        }
        
        // 如果有工具执行结果
        if (state.getLastToolResult() != null) {
            response.append(state.getLastToolResult().toString());
        } else if (lastResult != null && lastResult.getMessage() != null) {
            response.append(lastResult.getMessage());
        } else {
            response.append("任务已完成，但没有具体结果。");
        }
        
        // 添加执行统计信息
        if (logger.isDebugEnabled()) {
            response.append(String.format("\n\n[调试信息] 执行步骤: %d, 最终状态: %s", 
                                        state.getStepCount(), state.getTaskStatus()));
        }
        
        return response.toString();
    }
    
    /**
     * 获取已注册的节点列表
     * @return 节点名称列表
     */
    public Map<String, String> getRegisteredNodes() {
        Map<String, String> nodes = new HashMap<>();
        for (Map.Entry<String, AgentNode> entry : nodeRegistry.entrySet()) {
            nodes.put(entry.getKey(), entry.getValue().getNodeDescription());
        }
        return nodes;
    }
    
    /**
     * 检查节点是否已注册
     * @param nodeName 节点名称
     * @return 是否已注册
     */
    public boolean isNodeRegistered(String nodeName) {
        return nodeRegistry.containsKey(nodeName);
    }
    
    /**
     * 获取节点数量
     * @return 节点数量
     */
    public int getNodeCount() {
        return nodeRegistry.size();
    }
}

